Перейти к основному содержимому

5.16. Функции и команды

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ
Разработчику Архитектору

Функции и команды​

Ассемблер — это язык низкого уровня, максимально приближенный к машинному коду. Он предоставляет прямой контроль над аппаратными ресурсами процессора: регистрами, памятью, флагами и системными вызовами. На этом уровне программирования отсутствуют абстракции, характерные для высокоуровневых языков, такие как автоматическое управление памятью, типизация или встроенные конструкции для управления потоком выполнения. Вместо этого программист работает с конкретными инструкциями процессора, которые напрямую управляют поведением вычислительной системы.

В ассемблере понятия «функция» и «команда» имеют разное значение, но тесно связаны между собой. Команда — это элементарная операция, которую выполняет процессор. Функция — это логически завершённый блок кода, предназначенный для решения определённой задачи и многократного использования. В контексте ассемблера функции реализуются через механизм подпрограмм, а команды — это те самые инструкции, из которых состоит каждая подпрограмма.

Команды: основа исполнения​

Каждая команда в ассемблере соответствует одной машинной инструкции. Она описывает действие, которое процессор должен выполнить: загрузить данные из памяти, сложить два числа, изменить состояние флага, перейти по адресу или вызвать подпрограмму. Набор доступных команд определяется архитектурой процессора — например, x86, ARM, RISC-V. Эти команды формируют основу всего программного поведения.

Команды могут быть арифметическими (ADD, SUB, MUL), логическими (AND, OR, XOR), управляющими (JMP, CALL, RET), перемещения данных (MOV, PUSH, POP), сравнения (CMP) и другие. Каждая команда принимает операнды — источники и получатели данных. Операндами могут быть регистры, значения в памяти или непосредственные константы.

Программа на ассемблере представляет собой последовательность таких команд, исполняемых процессором по порядку, если не происходит явного изменения потока управления. Поток управления — это порядок, в котором выполняются команды. Он может быть изменён с помощью переходов, вызовов подпрограмм и возвратов.

Подпрограммы: организация повторного использования кода​

Подпрограмма — это именованный блок кода, который можно вызвать из разных мест программы. В ассемблере подпрограммы реализуются с помощью двух ключевых команд: CALL и RET.

Команда CALL выполняет два действия одновременно:

  1. Сохраняет адрес следующей команды (то есть точку возврата) в стеке.
  2. Передаёт управление на начало подпрограммы, указав её метку или адрес.

Команда RET извлекает сохранённый адрес из стека и передаёт управление обратно в точку вызова. Таким образом, подпрограмма завершается, и выполнение продолжается с того места, где произошёл вызов.

Этот механизм позволяет многократно использовать один и тот же код без дублирования. Подпрограммы служат базовым строительным блоком для структурирования программ на ассемблере, аналогично функциям в высокоуровневых языках.

Передача параметров​

Поскольку ассемблер не содержит встроенных механизмов для передачи аргументов, программист сам определяет способ, которым подпрограмма получает входные данные. Существует два основных подхода:

Передача через регистры.
Регистры — это самые быстрые ячейки памяти внутри процессора. Использование регистров для передачи параметров обеспечивает высокую производительность. Программист заранее договаривается, какие регистры будут содержать какие аргументы. Например, первый аргумент может передаваться через регистр RDI, второй — через RSI (в соответствии с соглашениями ABI, такими как System V AMD64). Этот способ прост и эффективен, но ограничен количеством доступных регистров.

Передача через стек.
Если параметров много или они слишком велики для размещения в регистрах, используется стек. Перед вызовом подпрограммы вызывающая сторона помещает аргументы в стек с помощью команды PUSH. Подпрограмма затем читает эти значения, обращаясь к определённым смещениям относительно указателя стека (SP) или базового указателя (BP). После завершения работы подпрограммы ответственность за очистку стека может лежать либо на вызывающей стороне, либо на самой подпрограмме — в зависимости от принятого соглашения о вызове.

Оба подхода дополняют друг друга. Часто используются гибридные схемы: первые несколько аргументов передаются через регистры, остальные — через стек.

Сохранение и восстановление контекста​

Процессор содержит ограниченное количество регистров. При вызове подпрограммы существует риск, что она изменит значения регистров, которые вызывающая сторона ещё планирует использовать. Чтобы избежать потери данных, применяется механизм сохранения контекста.

Контекст — это текущее состояние регистров и флагов процессора. Перед выполнением своей логики подпрограмма может сохранить нужные регистры в стек с помощью команды PUSH. По завершении работы она восстанавливает их с помощью POP в обратном порядке. Это гарантирует, что после возврата из подпрограммы вызывающий код продолжит работу с теми же значениями, с которыми он начал.

Некоторые регистры считаются «вызывающим сохраняемыми» (caller-saved), а другие — «вызываемым сохраняемыми» (callee-saved). Это часть соглашений о вызове, которые стандартизируют поведение программ и библиотек. Например, в System V ABI регистры RBX, RBP, R12–R15 должны сохраняться вызываемой подпрограммой, если она их использует. Регистры RAX, RCX, RDX могут быть изменены без предупреждения, и вызывающая сторона должна сама позаботиться об их сохранении, если это необходимо.

Соблюдение этих правил делает подпрограммы совместимыми и предсказуемыми в составе больших программ.

Возвращаемые значения​

Подпрограммы могут не только принимать параметры, но и возвращать результат. В ассемблере возвращаемое значение обычно передаётся через регистр. Например, в большинстве соглашений о вызове целочисленный результат возвращается в регистре RAX (или EAX в 32-битном режиме). Если результат слишком велик для одного регистра, могут использоваться пары регистров или передача через указатель, переданный как аргумент.

Такой подход требует явного согласования между вызывающей и вызываемой сторонами, но обеспечивает максимальную гибкость и производительность.

Пример структуры подпрограммы​

Типичная подпрограмма на ассемблере включает следующие этапы:

  1. Сохранение контекста.
    Подпрограмма сохраняет регистры, которые она будет использовать и которые обязаны быть восстановлены.

  2. Настройка базового указателя (опционально).
    Для удобства доступа к параметрам и локальным переменным часто устанавливается базовый указатель (PUSH RBP; MOV RBP, RSP). Это создаёт чёткую структуру фрейма стека.

  3. Выполнение основной логики.
    Здесь происходят вычисления, работа с памятью, вызовы других подпрограмм.

  4. Подготовка возвращаемого значения.
    Результат помещается в соответствующий регистр.

  5. Восстановление контекста.
    Регистры восстанавливаются в обратном порядке.

  6. Возврат.
    Выполняется команда RET, которая передаёт управление обратно вызывающему коду.

Эта структура обеспечивает предсказуемость, совместимость и возможность отладки.

Значение подпрограмм в архитектуре программ​

Подпрограммы — это не просто технический приём, а фундаментальный принцип организации кода. Они позволяют разделять программу на логические модули, каждый из которых решает свою задачу. Это упрощает чтение, тестирование и сопровождение кода. Даже в ассемблере, где всё управляется вручную, подпрограммы создают иерархию: основная программа вызывает вспомогательные блоки, те, в свою очередь, могут вызывать другие.

Без подпрограмм любая нетривиальная программа превратилась бы в спагетти-код — запутанную последовательность переходов без чёткой структуры. Механизм CALL/RET вводит дисциплину в управление потоком выполнения и делает возможным создание сложных систем даже на уровне машинных инструкций.

Рекурсия и стек вызовов​

Подпрограммы в ассемблере могут вызывать сами себя — это называется рекурсией. Хотя рекурсия чаще ассоциируется с высокоуровневыми языками, она полностью реализуема и на уровне машинных инструкций. Каждый новый вызов подпрограммы помещает в стек новую запись с адресом возврата и, при необходимости, параметрами и локальными данными. Таким образом формируется стек вызовов — цепочка вложенных контекстов выполнения.

Рекурсивная подпрограмма должна содержать условие завершения, иначе она приведёт к бесконечному росту стека и, в конечном счёте, к его переполнению. Условие проверяется с помощью команд сравнения (CMP) и условных переходов (JZ, JNE и другие). Если условие выполнено, подпрограмма возвращает управление без повторного вызова.

Рекурсия особенно полезна при работе с древовидными структурами данных, обходе графов или вычислении математических функций, таких как факториал или числа Фибоначчи. Однако в ассемблере рекурсия требует особой осторожности: каждый уровень вызова потребляет память, и отсутствие явного контроля над глубиной может привести к нестабильности программы.

Обработка ошибок и исключений​

В отличие от высокоуровневых языков, где существуют конструкции try/catch, ассемблер не предоставляет встроенных средств обработки исключений. Вместо этого программист использует флаги процессора и условные переходы для реакции на ошибочные состояния.

Например, после выполнения деления (DIV) процессор устанавливает флаг переполнения, если результат не помещается в регистр. После операций с памятью можно проверять корректность адресов. Подпрограмма может возвращать специальное значение (например, ноль или отрицательное число) в качестве сигнала об ошибке, а вызывающий код — проверять его перед продолжением.

В системах, где требуется строгая надёжность, применяются соглашения: каждая подпрограмма документирует возможные коды возврата, а вызывающая сторона обязана их обрабатывать. Это создаёт дисциплину, аналогичную контрактному программированию.

Взаимодействие с операционной системой​

Подпрограммы в ассемблере часто используются для вызова системных функций — например, чтения файла, вывода текста на экран или выделения памяти. Такие вызовы реализуются через системные прерывания или syscall-инструкции, в зависимости от архитектуры.

Программист помещает номер системного вызова и его аргументы в определённые регистры, затем выполняет команду INT 0x80 (в 32-битном Linux) или SYSCALL (в 64-битном). Операционная система перехватывает запрос, выполняет операцию и возвращает результат в регистр.

Эти системные вызовы сами по себе являются подпрограммами, предоставляемыми ядром ОС. Они следуют строгим соглашениям о передаче параметров и возврате значений, что позволяет ассемблерным программам интегрироваться с операционной средой без использования библиотек высокого уровня.

Пример: подпрограмма сложения двух чисел​

Рассмотрим простую подпрограмму на ассемблере x86-64 (синтаксис NASM), которая складывает два 64-битных целых числа и возвращает результат:

section .text
global _start

; Подпрограмма add_numbers
; Принимает: RDI = первое число, RSI = второе число
; Возвращает: RAX = сумма
add_numbers:
    push rbp          ; Сохраняем базовый указатель
    mov rbp, rsp      ; Устанавливаем новый фрейм стека

    mov rax, rdi      ; Загружаем первое число в RAX
    add rax, rsi      ; Прибавляем второе число

    pop rbp           ; Восстанавливаем базовый указатель
    ret               ; Возврат к вызывающему коду

_start:
    mov rdi, 10       ; Первый аргумент
    mov rsi, 25       ; Второй аргумент
    call add_numbers  ; Вызов подпрограммы

    ; Теперь RAX содержит 35
    ; Дальнейшие действия — например, вывод или выход

В этом примере соблюдены ключевые принципы:

  • Параметры передаются через регистры (RDI, RSI).
  • Контекст (RBP) сохраняется и восстанавливается.
  • Результат возвращается через RAX.
  • Используется стандартный механизм CALL/RET.

Такой стиль написания делает код читаемым, предсказуемым и совместимым с другими модулями.

Соглашения о вызове (Calling Conventions)​

Соглашения о вызове — это правила, определяющие, как функции получают аргументы, возвращают значения и управляют регистрами. Они стандартизируют взаимодействие между разными частями программы, включая сторонние библиотеки и системные вызовы.

Наиболее распространённые соглашения:

  • System V AMD64 ABI (используется в Linux, macOS): первые шесть целочисленных аргументов передаются через RDI, RSI, RDX, RCX, R8, R9; возвращаемое значение — в RAX; регистры RBX, RBP, R12–R15 сохраняются вызываемой стороной.
  • Microsoft x64 calling convention (Windows): аргументы передаются через RCX, RDX, R8, R9; остальные — через стек; возврат — в RAX.

Соблюдение этих соглашений обязательно при написании кода, который взаимодействует с компиляторами, библиотеками или операционной системой. Нарушение правил приведёт к повреждению данных, сбоям или непредсказуемому поведению.

Локальные переменные и стековый фрейм​

Подпрограммы часто нуждаются во временных переменных, которые существуют только в течение их выполнения. Для этого используется стековый фрейм — область памяти в стеке, выделяемая при входе в подпрограмму.

Обычно это делается так:

  1. Сохраняется текущий RBP (PUSH RBP).
  2. RBP устанавливается равным текущему RSP (MOV RBP, RSP).
  3. При необходимости стек расширяется (SUB RSP, N), чтобы выделить место под локальные данные.
  4. Переменные адресуются как [RBP - 8], [RBP - 16] и так далее.
  5. Перед выходом стек восстанавливается (MOV RSP, RBP), и RBP возвращается (POP RBP).

Этот подход обеспечивает изолированное пространство для каждой активации подпрограммы, что особенно важно при рекурсии или вложенных вызовах.